import pytest  # used for our unit tests
from codeflash.languages.javascript.treesitter_utils import TreeSitterAnalyzer

# Helper "realistic" in-test node implementation:
# We provide a minimal concrete node class that exposes the attributes and methods
# the TreeSitterAnalyzer._node_has_return implementation expects:
# - .type (str)
# - .children (list of nodes)
# - .child_by_field_name(name) -> node or None
#
# NOTE: In the real code this would be a tree_sitter.Node. For unit-testing the
# traversal logic we must supply objects that have the same runtime attributes
# and behavior. This keeps tests deterministic and simple.
class SimpleNode:
    def __init__(self, node_type: str, children=None, field_name: str | None = None):
        # Node type (e.g. "return_statement" or "function_declaration")
        self.type = node_type
        # Children must be a list; ensure defensive copy to avoid accidental sharing
        self.children = list(children) if children else []
        # Optional name for child_by_field_name matching
        self._field_name = field_name

    # Method required by the algorithm under test
    def child_by_field_name(self, name: str):
        # Return the first child whose _field_name matches the requested name
        for c in self.children:
            if getattr(c, "_field_name", None) == name:
                return c
        return None

    # Helpful repr for debugging failures
    def __repr__(self):
        return f"SimpleNode(type={self.type!r}, children={len(self.children)}, field={getattr(self,'_field_name',None)!r})"

# Utility function to obtain an instance of TreeSitterAnalyzer without invoking
# its potentially complex constructor. We intentionally avoid calling __init__
# because _node_has_return is an instance method that does not rely on
# instance-initialized state; calling __init__ might require unavailable
# dependencies (language enums, parser compilation, etc.). We still produce a
# real instance of the actual class (by bypassing __init__), keeping the tests
# focused on the method behavior.
def get_analyzer_instance():
    # Create a bare instance without running __init__
    inst = object.__new__(TreeSitterAnalyzer)
    # Provide attributes that might be accessed elsewhere (not strictly needed
    # for _node_has_return, but harmless to include)
    inst.language = None
    inst._parser = None
    inst._function_types_cache = {}
    return inst

def test_direct_return_node():
    # A node that itself is a return statement should be detected immediately.
    node = SimpleNode("return_statement")
    analyzer = get_analyzer_instance()
    # Expect True because node.type == "return_statement"
    codeflash_output = analyzer._node_has_return(node) # 867ns -> 1.25μs (30.6% slower)

def test_empty_root_no_return():
    # An empty root node with no children and non-return type should be False.
    node = SimpleNode("program", children=[])
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(node) # 1.23μs -> 1.45μs (15.0% slower)

def test_nested_return_in_non_function():
    # A return nested inside non-function nodes should be found.
    inner = SimpleNode("return_statement")
    middle = SimpleNode("expression_statement", children=[inner])
    root = SimpleNode("program", children=[middle])
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(root) # 2.61μs -> 2.66μs (1.99% slower)

def test_return_inside_function_body_is_found():
    # When a function-like node has a body child containing a return,
    # the algorithm should traverse only the body and detect the return.
    ret = SimpleNode("return_statement")
    body = SimpleNode("block", children=[ret], field_name="body")
    # Create a function-like node. It must have a child that is discoverable
    # via child_by_field_name("body").
    func = SimpleNode("function_declaration", children=[body])
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(func) # 2.60μs -> 2.74μs (5.19% slower)

def test_return_in_function_non_body_child_ignored():
    # If a function-like node has a return in a non-body child (e.g. params),
    # that return should NOT be traversed (and thus not detected).
    # Build a function_declaration with a "param" child containing a return,
    # and no "body" child.
    ret = SimpleNode("return_statement")
    param = SimpleNode("identifier", children=[ret], field_name="param")
    func = SimpleNode("function_declaration", children=[param])
    analyzer = get_analyzer_instance()
    # Because the algorithm only traverses the 'body' field of function nodes,
    # it must not see the return inside 'param'. Therefore the result is False.
    codeflash_output = analyzer._node_has_return(func) # 1.43μs -> 1.52μs (5.72% slower)

def test_function_with_body_but_no_children_returns_false():
    # A function node with an explicit body child that itself has no children
    # should result in False (no return inside body).
    empty_body = SimpleNode("block", children=[], field_name="body")
    func = SimpleNode("function_expression", children=[empty_body])
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(func) # 1.49μs -> 1.63μs (8.53% slower)

def test_nonstandard_node_type_but_children_contain_return():
    # Node types not in func_types should traverse all children.
    # Ensure that if a non-function node has a child which is a function that
    # hides a return, the parent traversal still follows rules correctly.
    hidden_return = SimpleNode("return_statement")
    inner_body = SimpleNode("block", children=[hidden_return], field_name="body")
    inner_func = SimpleNode("function_expression", children=[inner_body])
    outer = SimpleNode("wrapper", children=[inner_func])
    analyzer = get_analyzer_instance()
    # The return is inside the body of the function, which should be traversed,
    # so we expect True.
    codeflash_output = analyzer._node_has_return(outer) # 2.67μs -> 2.72μs (1.88% slower)

def test_many_siblings_without_return_performance():
    # Create a root with 1000 sibling nodes none of which are return statements.
    # Expect False and ensure it completes quickly (pytest will naturally time out
    # on pathological implementations).
    siblings = [SimpleNode("expression") for _ in range(1000)]
    root = SimpleNode("program", children=siblings)
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(root) # 86.1μs -> 67.3μs (28.1% faster)

def test_deep_nesting_with_return_at_bottom():
    # Create a chain of 1000 nested single-child nodes with a return at the leaf.
    # This stresses the stack/iteration logic but should still find the return.
    depth = 1000
    leaf = SimpleNode("return_statement")
    current = leaf
    # Build nesting: node0 -> node1 -> ... -> leaf
    for i in range(depth):
        current = SimpleNode("block", children=[current])
    root = SimpleNode("program", children=[current])
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(root) # 198μs -> 176μs (12.4% faster)

def test_many_functions_with_internal_returns_ignored_if_no_body():
    # Create many function-like nodes with return statements in non-body children.
    # Since none have a 'body' child, none of these internal returns should be
    # discovered. This ensures the implementation correctly avoids traversing
    # non-body parts of function nodes at scale.
    funcs = []
    for i in range(500):
        # each function has a return inside a "param" child but lacks a "body"
        inner_ret = SimpleNode("return_statement")
        param = SimpleNode("param", children=[inner_ret], field_name="param")
        func = SimpleNode("method_definition", children=[param])
        funcs.append(func)
    root = SimpleNode("program", children=funcs)
    analyzer = get_analyzer_instance()
    codeflash_output = analyzer._node_has_return(root) # 98.0μs -> 89.0μs (10.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.